/**
 * 扩展ZTree
 * @Author DaiJiang
 * @Email aokser@foxmail.com
 * @Version 1.0
 */
var Tree = function (config) {

    var _this = this;

    /**
     * Tree ID
     * @type {string}
     */
    this._id = '';

    /**
     * 节点信息
     * @type {Array}
     */
    this._nodes = [];

    /**
     * [节点类型]
     * @type {Object}
     */
    Tree._NODE_TYPE = {ORG: 'org', DEVICE: 'car'};


    /**
     * 节点图标样式
     * @type {Object}
     */
    Tree._NODE_ICON = {
        // 在线
        online: 'online',
        // 离线
        offline: 'offline',
        // 停车在线
        stop_onlie: 'stop_onlie',

    }

    /**
     * 保存 zTree 内部需要的常量
     * @type {{}}
     * @private
     */
    this._consts = {};

    /**
     * 事件类型
     */
    Tree._EVENT_NAME = {
        beforeAsync: 'beforeAsync',
        beforeCheck: 'beforeCheck',
        beforeClick: 'beforeClick',
        beforeCollapse: 'beforeCollapse',
        beforeDblClick: 'beforeDblClick',
        beforeDrag: 'beforeDrag',
        beforeDragOpen: 'beforeDragOpen',
        beforeDrop: 'beforeDrop',
        beforeEditName: 'beforeEditName',
        beforeExpand: 'beforeExpand',
        beforeMouseDown: 'beforeMouseDown',
        beforeMouseUp: 'beforeMouseUp',
        beforeRemove: 'beforeRemove',
        beforeRename: 'beforeRename',
        beforeRightClick: 'beforeRightClick',
        onAsyncError: 'onAsyncError',
        onAsyncSuccess: 'onAsyncSuccess',
        onCheck: 'onCheck',
        onClick: 'onClick',
        onCollapse: 'onCollapse',
        onDblClick: 'onDblClick',
        onDrag: 'onDrag',
        onDragMove: 'onDragMove',
        onDrop: 'onDrop',
        onExpand: 'onExpand',
        onMouseDown: 'onMouseDown',
        onMouseUp: 'onMouseUp',
        onNodeCreated: 'onNodeCreated',
        onRemove: 'onRemove',
        onRename: 'onRename',
        onRightClick: 'onRightClick'
    }

    /**
     * 保存 zTree 需要的配置信息（完全可以利用这个为自己的项目制作 zTree 的公共默认配置，减少页面代码）
     * @type {{}}
     * @private
     */
    this._setting = {
        /**
         * 默认异步配置
         */
        async: {enable: false, url: '', type: 'get'},

        /**
         * 勾选 checkbox 对于父子节点的关联关系。[setting.check.enable = true 且 setting.check.chkStyle = "checkbox" 时生效]
         */
        check: {
            // 设置 zTree 的节点上是否显示 checkbox / radio
            enable: true,
            // 勾选框类型(checkbox 或 radio）[setting.check.enable = true 时生效]
            chkStyle: "checkbox",
            // 勾选 checkbox 对于父子节点的关联关系。[setting.check.enable = true 且 setting.check.chkStyle = "checkbox" 时生效]
            chkboxType: {"Y": "ps", "N": "ps"}
        },

        data: {
            // 确定 zTree 初始化时的节点数据、异步加载时的节点数据、或 addNodes 方法中输入的 newNodes 数据是否采用简单数据模式 (Array)
            simpleData: {enable: true}
        },

        view: {expandSpeed: ''},

        /**
         * 回调
         */
        callback: {
            /**
             * 用于捕获异步加载之前的事件回调函数，zTree 根据返回值确定是否允许进行异步加载
             * 默认值：null
             */
            beforeAsync: null,
            /**
             * 用于捕获 勾选 或 取消勾选 之前的事件回调函数，并且根据返回值确定是否允许 勾选 或 取消勾选
             * 默认值：null
             */
            beforeCheck: null,
            /**
             * 用于捕获单击节点之前的事件回调函数，并且根据返回值确定是否允许单击操作
             * 默认值：null
             */
            beforeClick: null,
            beforeCollapse: null,
            beforeDblClick: null,
            beforeDrag: null,
            beforeDragOpen: null,
            beforeDrop: null,
            beforeEditName: null,
            beforeExpand: null,
            beforeMouseDown: null,
            beforeMouseUp: null,
            beforeRemove: null,
            beforeRename: null,
            /**
             * 用于捕获 zTree 上鼠标右键点击之前的事件回调函数，并且根据返回值确定触发 onRightClick 事件回调函数
             * 默认值：null
             */
            beforeRightClick: null,
            /**
             * 用于捕获异步加载出现异常错误的事件回调函数
             * 如果设置了 setting.callback.beforeAsync 方法，且返回 false，将无法触发 onAsyncSuccess /
             * onAsyncError 事件回调函数。
             * 默认值：null
             */
            onAsyncError: null,
            /**
             * 用于捕获异步加载正常结束的事件回调函数
             * 如果设置了 setting.callback.beforeAsync 方法，且返回 false，将无法触发 onAsyncSuccess /
             * onAsyncError 事件回调函数。
             * 默认值：null
             */
            onAsyncSuccess: null,
            /**
             * 用于捕获 checkbox / radio 被勾选 或 取消勾选的事件回调函数
             * 如果设置了 setting.callback.beforeCheck 方法，且返回 false，将无法触发 onCheck 事件回调函数。
             * 默认值：null
             */
            onCheck: function(event, treeId, treeNode) {
                // 事件被禁用
                if(_this._nodeCheckConfig.disabledCheck) {
                    console.log('check 事件被禁用.');
                    treeNode.checked = false;
                    return false;
                }

                // 只允许单选
                if(!_this._nodeCheckConfig.allowMulti) {
                    // 当前节点被选中
                    if(treeNode.checked) {
                        // 获取所有选中的节点
                        var checkedNodes = _this.getNodesByChecked(true);

                        // 遍历并更新节点为非选中状态
                        for(var i=0; i<checkedNodes.length; i++) {
                            // 排除当前节点
                            if(checkedNodes[i].id != treeNode.id) {
                                checkedNodes[i].checked = false;
                                _this.updateNode(checkedNodes[i]);
                            }
                            
                        }
                    }
                }

                // 允许指定的nodeType节点触发check事件
                if(treeNode.nodeType && treeNode.nodeType == _this._nodeCheckConfig.nodeType) {
                    _this.customEvent.onCheck(event, treeId, treeNode);
                    return true;
                }
            },
            /**
             * 用于捕获节点被点击的事件回调函数
             * 如果设置了 setting.callback.beforeClick 方法，且返回 false，将无法触发 onClick 事件回调函数。
             * 默认值：null
             */
            onClick: function(event, treeId, treeNode) {
                // 点击时是否执行勾选
                if(_this._nodeClickConfig.allowCheck) {
                    _this.getZTreeObj().checkNode(treeNode, !treeNode.checked, true, true); 
                }
                
                
                _this.customEvent.onClick(event, treeId, treeNode);
                return true;
            },

            /**
             * 用于捕获节点被折叠的事件回调函数
             * 如果设置了 setting.callback.beforeCollapse 方法，且返回 false，将无法触发 onCollapse 事件回调函数。
             * 默认值：null
             */
            onCollapse: null,
            /**
             * 用于捕获 zTree 上鼠标双击之后的事件回调函数
             * 如果设置了 setting.callback.beforeDblClick 方法，且返回 false，将无法触发 onDblClick 事件回调函数。
             * 默认值：null
             */
            onDblClick: null,
            onDrag: null,
            onDragMove: null,
            onDrop: null,
            /**
             * 用于捕获节点被展开的事件回调函数
             * 如果设置了 setting.callback.beforeExpand 方法，且返回 false，将无法触发 onExpand 事件回调函数。
             * 默认值：null
             */
            onExpand: null,
            onMouseDown: null,
            onMouseUp: null,
            onNodeCreated: null,
            onRemove: null,
            onRename: null,

            /**
             * 用于捕获 zTree 上鼠标右键点击之后的事件回调函数
             * 1、如果设置了 setting.callback.beforeRightClick 方法，且返回 false，将无法触发 onRightClick 事件回调函数。
             * 2、只要将 function 的引用赋给 onRightClick 属性，则右键点击 zTree 时，将屏蔽浏览器的右键菜单。
             * 默认值：null
             */
            onRightClick: function(event, treeId, treeNode) {
                if(_this._nodeClickConfig.showRightMenu) {
                    _this.customEvent.onRightClick(event, treeId, treeNode);
                    return true;
                } else {
                    return false;
                }
                
            }
        }
    };

    /**
     * [自定义事件]
     * @type {Object}
     */
    this.customEvent = {

        onCheck: function(){},
        
        /**
         * [默认实现自定义右键事件]
         * @param  {[type]} event    [事件对象]
         * @param  {[type]} treeId   [tree id]
         * @param  {[type]} treeNode [tree node]
         * @return {[type]}          [none]
         */
        onRightClick: function(event, treeId, treeNode){
            _this.rightMenuHandler(treeNode, {"edit": {name: "添加关注", icon: "add"}}, _this.addFollow);
        },

        onClick: function(){},
    }

    /**
     * 注册事件
     * @param registerEvent
     * @param handler
     */
    this.registerEvent = function (eventName, handler) {
        if (typeof eventName != 'string') {
            return;
        }
        if (typeof handler != 'function') {
            return;
        }
        for (p in Tree._EVENT_NAME) {
            if (Tree._EVENT_NAME[p] == eventName) {
                // this._setting.callback[p] = handler;
                this.customEvent[p] = handler;
                break;
            }
        }
    }

    /**
     * 设置异步对象信息
     * @param config
     */
    this.setAsync = function (config) {
        if (config && this._setting.async[p]) {
            for (p in config) {
                this._setting.async[p] = config[p];
            }
        }
    }

    this.initRoot = function (setting) {
    };

    /**
     * 设置 zTree 内部的缓存初始化(初始化时执行）
     * @param treeId
     * @private
     */
    this.initCache = function (treeId) {
    };

    /**
     * 设置 zTree 内部事件回调函数(初始化时执行）  例如：onCheck等
     * @param setting
     * @private
     */
    this.bindEvent = function (setting) {
    };

    /**
     * 设置 zTree 事件代理中的处理逻辑，根据不同事件跳转到不同的 handler 处理 ( *** 参考 excheck 代码，如果使用必须 return proxyResult  *** )
     * @param e
     * @private
     */
    this.eventProxy = function (e) {
    };

    /**
     * 设置 节点数据初始化的处理(加载节点时执行)
     * @param setting
     * @param level
     * @param n
     * @param parentNode
     * @param isFirstNode
     * @param isLastNode
     * @param openFlag
     * @private
     */
    this.initNode = function (setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) {
    };

    /**
     * 专门用于在节点<a>之前生成 DOM 使用，主要用于 checkbox & radio
     * @param setting
     * @param node
     * @param html
     * @private
     */
    this.beforeA = function (setting, node, html) {
    };

    /**
     * 设置 zTreeObj 的各种对外方法，可以制作新的接口也可以覆盖已有接口
     * @param setting
     * @param zTreeTools
     * @private
     */
    this.zTreeTools = function (setting, zTreeTools) {
        zTreeTools.a = function () {
        };
        zTreeTools.b = function () {
        };

    };

    /**
     * 定义 zTree 节点数据操作的方法
     * @type {{}}
     * @private
     */
    this._data = {};

    /**
     * 定义 zTree 各种事件绑定 & Proxy 的方法
     * @type {{}}
     * @private
     */
    this._event = {};

    /**
     * 定义 zTree 事件处理的方法
     * @type {{}}
     * @private
     */
    this._handler = {};

    /**
     * 定义 zTree 内部的工具方法
     * @type {{}}
     * @private
     */
    this._tools = {};

    /**
     * 定义 zTree 视图相关的方法
     * @type {{}}
     * @private
     */
    this._view = {
        addHoverDom: function (treeId, treeNode) {
            // 显示模态
            if (_this._mouseoverConfig.showModal) {
                // 生成模态Win
                _this.showMouseOverWin(treeNode);
            }
        }
    };

    /**
     * 将本扩展库内的方法、属性注入到 core 中
     * @type {{tools: {}, view: {}, event: {}, data: {}}}
     * @private
     */
    this._z = {
        tools: this._tools,
        view: this._view,
        event: this._event,
        data: this._data
    };

    /**
     * 拷贝配置
     */
    $.extend(true, this, config);

    /**
     * 将自定义的常量复制给zTree常量
     */
    $.extend(true, $.fn.zTree.consts, this._consts);

    /**
     * 将自定义扩展的tools 、view 、veent、data复制给zTree
     */
    $.extend(true, $.fn.zTree._z, this._z);

    /**
     * 获取几个主要的全局对象
     */
    this.ztree  = $.fn.zTree;
    this.tools  = this.ztree._z.tools;
    this.consts = this.ztree.consts;
    this.view   = this.ztree._z.view;
    this.data   = this.ztree._z.data;
    this.event  = this.ztree._z.event

    /**
     * 针对 zTree 初始化进行注入新内容 合并 配置 setting
     */
    this.data.exSetting(this._setting);

    /**
     * 添加 绑定事件处理
     */
    this.data.addInitBind(this.bindEvent);

    /**
     * 添加 初始化 Cache 方法
     */
    this.data.addInitCache(this.initCache);

    /**
     * 添加 初始化 节点数据 方法
     */
    this.data.addInitNode(this.initNode);

    /**
     * 添加 初始化 事件代理 方法
     */
    // this.data.addInitProxy(this.eventProxy);

    /**
     * 添加 初始化 zTree 内部基本属性 方法
     */
    this.data.addInitRoot(this.initRoot);

    /**
     * 添加 初始化节点 <A> 之前的DOM 方法
     */
    this.data.addBeforeA(this.beforeA);

    /**
     * 添加 zTreeObj 对象的对外接口
     */
    this.data.addZTreeTools(this.zTreeTools);

    /** ******************************自定义方法*************************** **/
    /**
     * 获取原生的ZTree对象
     * init (obj, zSetting, zNodes)
     * getZTreeObj (treeId)
     * destroy (treeId)
     * _z : {tools, view, event, data}
     * @returns {*|null}
     */
    this.getZTree = function () {
        return this.ztree;
    }

    /**
     * 获取Tree ID
     * @returns {string}
     */
    this.getTreeId = function () {
        return this.id;
    }

    /**
     * 获取ZTreeObj
     */
    this.getZTreeObj = function () {
        return this.getZTree().getZTreeObj(this.id);
    }

    /**
     * 根据勾选状态获取节点集合
     * @param  {[type]} checked [description]
     * @return {[type]}         [description]
     */
    this.getNodesByChecked = function(checked) {
        // 获取输入框被勾选 或 未勾选的节点集合。[setting.check.enable = true 时有效]
        return this.getZTreeObj().getCheckedNodes(checked);
    }

    /**
     * [根据节点类型过滤节点]
     * @param  {[type]} nodes    [目标节点集合]
     * @param  {[String]} nodeType [节点类型]
     * @return {[type]}          [Array]
     */
    this.filterNodesByNodeType = function(nodes, nodeType) {
        var rs = [];
        if(nodes && nodeType && nodes instanceof Array) {
            for(var i=0; i<nodes.length; i++) {
                if(nodes[i].nodeType) {
                    if(nodes[i].nodeType != nodeType) {
                        rs.push(nodes[i]);
                    }
                }
            }
        }
        return rs;
    }

    /**
     * [更新某节点数据，主要用于该节点显示属性的更新]
     * [用此方法修改 checked 勾选状态不会触发 beforeCheck / onCheck 事件回调函数]
     * @param  {[JSON]} node [description]
     * @param  {[Boolean]} checkTypeFlag [checkTypeFlag = true 表示按照 setting.check.chkboxType 属性进行父子节点的勾选联动操作；checkTypeFlag = false 表示只修改此节点勾选状态，无任何勾选联动操作]
     * @return {[type]}      [none]
     */
    this.updateNode = function(node) {
        return this.getZTreeObj().updateNode(node);
    }

    /**
     * 禁用 或 解禁 某个节点的 checkbox / radio [setting.check.enable = true 时有效]
     * @param {[JSON]} node            [需要禁用 或 解禁 checkbox / radio 的节点数据]
     * @param {[Boolean]} disabled        [disabled = true 表示禁用 checkbox / radio, false反之]
     * @param {[Boolean]} inheritParent   [inheritParent = true 表示全部父节点进行同样的操作，false反之]
     * @param {[Boolean]} inheritChildren [inheritChildren = true 表示全部子节点进行同样的操作，false反之]
     */
    this.setChkDisabled = function(node, disabled, inheritParent, inheritChildren) {
        this.getZTreeObj().setChkDisabled(node, disabled, inheritParent, inheritChildren);
    }

    /**
     * [获取节点的勾选状态]
     * @param  {[JSON]} node [目标节点]
     * @return {[Boolean]}      [true, false]
     */
    this.getCheckStatus = function(node) {
        if(node) {
            return node.getCheckStatus().half;
        }
        return false;
    }

    /**
     * [勾选 或 取消勾选 全部节点]
     * @param  {[Boolean]} checked [true 表示勾选全部节点, false反之]
     * @return {[type]}         [description]
     */
    this.checkAllNodes = function(checked) {
        this.getZTreeObj().checkAllNodes(checked);
    }

    /**
     * [右键菜单句柄]
     * @param  {[type]} node [节点信息]
     * @param  {[object]} menus [菜单信息 {type: {name: '', icon: ''}}]
     * @param  {[function]} callback [菜单点击时的回调函数]
     * @return {[type]}      [description]
     */
    this.rightMenuHandler = function(node, menus, callback) {
        var id = node.tId;
        $.contextMenu({
                selector: '#' + id + "_a",
                className: 'context-menu-custom',
                callback: function(key, options) {
                    // if(typeof callback == 'function') {
                    //     callback(node, key, options);
                    // }
                },
                items: menus
            });
    }
    /**
     * [添加关注]
     * @param  {[type]} node    [节点信息]
     * @param  {[type]} key     [menu key]
     * @param  {[type]} options [menu options]
     * @return {[type]}         [none]
     */
    this.addFollow = function(node, key, options) {
        $.confirm({
            title: '添加关注',
            text: '确定添加到个人关注？',
            animation: 'zoom',
            closeAnimation: 'scale',
            confirmButtonClass: 'btn-info',
            cancelButtonClass: 'btn-danger',
            confirmButton: '确定',
            cancelButton: '取消',
            confirm: function () {
                $.ajax({
                    url: '/userfollow/' + carId,
                    dataType: 'json',
                    type:'POST',
                    success: function(rsp) {
                        alert(rsp.message);
                    },
                    error: function(XMLHttpRequest, textStatus, errorThrown) {
                        console.log(textStatus);
                    }
                });
            },
            cancel: function () {
                return;
            }
        });
    }
    /** *************************************************************** **/

};

/**
 * 自执行函数
 */
(function (window, $, Tree) {

    $.extend(Tree.prototype, {

        // 鼠标移动到节点时的配置
        _mouseoverConfig: {
            // 是否显示
            showModal: false,
            // 是否过滤节点
            isFilter: true,
            // 在指定的节点类型上启用, 默认设备节点启用
            nodeType: 'device'
            
        },

        // 节点点击配置信息
        _nodeClickConfig: {
            allowCheck: true,
            showRightMenu: false
        },

        // 节点check时的配置信息
        _nodeCheckConfig: {
            // 禁止check操作
            disabledCheck: false,
            // 允许check的节点类型
            nodeType: 'device',
            // 是否允许多选
            allowMulti: true

        },

        /**
         * [设置节点点击配置]
         * @param {[type]} config [description]
         */
        setNodeClickConfig: function(config) {
            if(config && typeof config == 'object') {
                for(p in config) {
                    this._nodeClickConfig[p] = config[p];
                }
            }
        },

        /**
         * [设置节点check配置]
         * @param {[type]} config [description]
         */
        setNodeCheckConfig: function(config) {
            if(config && typeof config == 'object') {
                for(p in config) {
                    this._nodeCheckConfig[p] = config[p];
                }
            }
        },

        /**
         * 设置节点鼠标移入配置
         * @param {[type]} config [description]
         */
        setMouseoverConfig: function(config) {
            if(config && typeof config == 'object') {
                for(p in config) {
                    this._mouseoverConfig[p] = config[p];
                }
            }
        },

        /**
         * [初始化]
         * @return {[type]} [description]
         */
        init: function () {
            this.getZTree().init($("#" + this.id), this._setting, this.nodes);
        },

        /**
         * 生成鼠标移动到节点上时弹出窗体
         * @param node 节点信息
         */
        genMouseOverWin: function (node) {
            var html = '';
            html += '<div id="carModel" class="col-lg-4" style="position: absolute;left:0;top:0;z-index:999;display: none; overflow:auto; font-size:12px;">';
            html += '<div class="panel panel-primary">';
            html += '<div id="tCarNo" class="panel-heading">';
            html += '<h3 class="panel-title">';
            html += '<a onclick="$(\'#carModel\').hide();"><i class="sr-only jconfirm-white"></i></a>';
            html += '</h3>';
            html += '</div>';
            html += '<div class="panel-body" style="padding:10px 0;">';

            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">车牌号:</label>';
            html += '<div id="car_number" class="col-sm-4" style="padding: 0;"></div>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">SIM卡号:</label>';
            html += '<div id="sm_card" class="col-sm-4" style="padding: 0;"></div>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">10位终端号:</label>';
            html += '<div id="end10_card" class="col-sm-4" style="padding: 0;"></div>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">7位终端号:</label>';
            html += '<div id="end7_number" class="col-sm-4" style="padding: 0;"></div>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">VIN码:</label>';
            html += '<div id="came" class="col-sm-4" style="padding: 0;"></div>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">车辆状态:</label>';
            html += '<div id="condition" class="col-sm-4" style="padding: 0;"></div>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">方向:</label>';
            html += '<div id="direction" class="col-sm-4" style="padding: 0;"></div>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">上报时间:</label>';
            html += '<div id="tTime" class="col-sm-4" style="padding: 0;"></div>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">电流:</label>';
            html += '<div id="tCurrent" class="col-sm-4" style="padding: 0;"></div>';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">电压:</label>';
            html += '<div id="tVoltage" class="col-sm-4" style="padding: 0;"></div>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">SOC:</label>';
            html += '<span id="tSOC" class="col-sm-4" style="padding: 0;"></span>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">车速:</label>';
            html += '<span id="tSpeed" class="col-sm-4" style="padding: 0;"></span>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">定制数据项:</label>';
            html += '<span id="tData" class="col-sm-4" style="padding: 0;"></span>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">当日里程:</label>';
            html += '<span id="tM" class="col-sm-4" style="padding: 0;"></span>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">总里程:</label>';
            html += '<span id="tAll" class="col-sm-4" style="padding: 0;"></span>';

            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">终端报警:</label>';
            html += '<span id="tAlarm" class="col-sm-4" style="padding: 0;"></span>';
            html += '</div>';
            html += '<div class="col-sm-12">';
            html += '<label class="col-sm-2 control-label" style="text-align: right; padding: 0;">地址:</label>';
            html += '<span id="tAddr" class="col-sm-10" style="padding: 0;"></span>';
            html += '</div>';
            html += '</div>';
            html += '</div>';
            html += '</div>';

            return html;
        },

        /**
         * 显示鼠标移动上去时的窗体
         */
        showMouseOverWin: function (node) {
            this.genMouseOverWin(node);
        },
    })

    // window.tree = Tree;

})(window, jQuery, Tree);

